require("dotenv").config()
const Koa = require("koa")
const app = new Koa()
const cors = require("@koa/cors")
const bodyParser = require("koa-bodyparser") // 新增请求体解析中间件

// 引入配置
const db = require("./config/db")

// 配置请求体解析（支持JSON格式）
app.use(bodyParser())

// 配置CORS
app.use(
  cors({
    origin: '*', // 生产环境建议限制具体域名
    allowMethods: ['GET', 'POST', 'DELETE', 'PUT', 'OPTIONS'],
    allowHeaders: ['Content-Type', 'Authorization'],
    exposeHeaders: ['Content-Length', 'Authorization']
  })
)

// 智能数据库初始化 - 真正检查表是否存在
async function initializeDatabase() {
  try {
    // console.log('开始数据库初始化检查...');

    // 检查数据库连接
    await db.pool.query('SELECT 1');
    console.log('-----数据库连接正常-----');

    // 检查每个表是否存在，只在不存在时初始化
    const tables = [
      { name: 'users', displayName: '用户表' },
      { name: 'articles', displayName: '文章表' },
      { name: 'categories', displayName: '分类表' },
      { name: 'tags', displayName: '标签表' },
      { name: 'article_tags', displayName: '文章标签关联表' },
      { name: 'about', displayName: '关于页面表' },
      { name: 'settings', displayName: '全局配置表' }
    ];

    let initializedCount = 0;
    let skippedCount = 0;

    // 逐个检查表（避免并发问题）
    for (const table of tables) {
      const exists = await db.checkTableExists(table.name);
      if (exists) {
        // console.log(`${table.displayName} 已存在，跳过初始化`);
        skippedCount++;
      } else {
        // console.log(`${table.displayName} 不存在，开始创建...`);

        // 根据表名调用对应的初始化函数
        switch (table.name) {
          case 'users':
            await db.initUserTable();
            break;
          case 'articles':
            await db.initArticleTable();
            break;
          case 'categories':
            await db.initCategoryTable();
            break;
          case 'tags':
            await db.initTagTable();
            break;
          case 'article_tags':
            await db.initArticleTagTable();
            break;
          case 'about':
            await db.initAboutTable();
            break;
          case 'settings':
            await db.initSettingsTable();
            break;
        }
        initializedCount++;
      }
    }

    console.log(`\n数据库初始化完成：${initializedCount} 个表新建，${skippedCount} 个表已存在`);

    // 显示最终状态统计
    try {
      const [tableStatus] = await db.pool.query(`
        SELECT 
          (SELECT COUNT(*) FROM users) as user_count,
          (SELECT COUNT(*) FROM articles) as article_count,
          (SELECT COUNT(*) FROM categories) as category_count,
          (SELECT COUNT(*) FROM tags) as tag_count
      `);

      if (tableStatus.length > 0) {
        console.log('\n数据库状态统计:');
        console.log(`- 用户表: ${tableStatus[0].user_count} 条记录`);
        console.log(`- 文章表: ${tableStatus[0].article_count} 条记录`);
        console.log(`- 分类表: ${tableStatus[0].category_count} 条记录`);
        console.log(`- 标签表: ${tableStatus[0].tag_count} 条记录`);
      }
    } catch (statsError) {
      console.log('状态统计查询失败（可能是表刚创建还没有数据）');
    }

  } catch (error) {
    console.error('数据库初始化失败:', error);

    // 根据错误类型决定是否继续启动
    if (error.code === 'ECONNREFUSED') {
      console.error('数据库连接失败，请检查数据库服务是否启动');
      process.exit(1); // 数据库连接失败，退出应用
    } else if (error.code === 'ER_BAD_DB_ERROR') {
      console.error('数据库不存在，请创建数据库或检查连接配置');
      process.exit(1); // 数据库不存在，退出应用
    } else {
      console.error('数据库初始化出现未知错误，继续启动应用...');
      // 其他错误不阻止应用启动，但记录日志
    }
  }
}

// 执行数据库初始化
initializeDatabase();

// 引入路由
const userRouter = require("./routes/user")
const testRouter = require("./routes/test")
const blogRouter = require("./routes/blog")
const categoryRouter = require("./routes/category")
const tagRouter = require("./routes/tag")
const aboutRouter = require("./routes/about")
const settingsRouter = require("./routes/settings")

// 数据库初始化（仅开发环境执行）
if (process.env.NODE_ENV === "development") {
  ; (async () => {
    const [existing] = await db.pool.query("SELECT * FROM articles LIMIT 1")
    if (existing.length === 0) {
      // 插入测试用户
      const [userResult] = await db.pool.query(
        "INSERT INTO users (username, password) VALUES (?, ?) ON DUPLICATE KEY UPDATE id=LAST_INSERT_ID(id)",
        ["testuser", "testpassword"]
      )
      const testUserId = userResult.insertId

      // 先插入测试分类
      const [categoryResult] = await db.pool.query(
        "INSERT INTO categories (name) VALUES (?), (?)",
        ["技术", "生活"]
      )

      const testArticles = [
        {
          title: "第一篇博客",
          content: "这是我的第一篇博客内容",
          category_id: 1, // 改为category_id
        },
        {
          title: "前端开发技巧",
          content: "分享React组件优化方法",
          category_id: 1, // 改为category_id
        },
        {
          title: "周末游记",
          content: "周末去了西湖游玩",
          category_id: 2, // 改为category_id
        },
      ]

      // 修改插入语句，移除tags字段
      const insertPromises = testArticles.map((article) =>
        db.pool.query(
          "INSERT INTO articles (title, content, category_id, author_id, create_time) VALUES (?, ?, ?, ?, NOW())",
          [
            article.title,
            article.content,
            article.category_id,
            testUserId,
          ]
        )
      )
      const articleResults = await Promise.all(insertPromises)

      // 如果有标签数据，还需要插入标签关联
      // 这里简化处理，后续可以添加标签关联逻辑

      console.log("成功初始化3篇测试文章")
    }
  })()
}

// 全局错误处理（捕获JWT过期等错误）
app.use(async (ctx, next) => {
  try {
    await next();
  } catch (err) {
    if (err.name === 'TokenExpiredError') {
      ctx.status = 401;
      ctx.body = { message: '令牌已过期，请重新登录' };
    } else {
      ctx.status = err.status || 500;
      ctx.body = { message: err.message || '服务器内部错误' };
    }
    // 错误响应也添加 CORS 头
    ctx.set('Access-Control-Allow-Origin', '*');
    ctx.set('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, OPTIONS');
    ctx.set('Access-Control-Allow-Headers', 'Content-Type, Authorization');
    ctx.set('Access-Control-Expose-Headers', 'Content-Length, Authorization');
  }
});

// 挂载路由
app.use(userRouter.routes()).use(userRouter.allowedMethods())
app.use(testRouter.routes()).use(testRouter.allowedMethods())
app.use(blogRouter.routes()).use(blogRouter.allowedMethods())
app.use(categoryRouter.routes()).use(categoryRouter.allowedMethods())
app.use(tagRouter.routes()).use(tagRouter.allowedMethods())
app.use(aboutRouter.routes()).use(aboutRouter.allowedMethods())
app.use(settingsRouter.routes()).use(settingsRouter.allowedMethods())

// 启动服务
const PORT = process.env.PORT || 9090
app.listen(PORT, () => {
  console.log(`Server running on http://127.0.0.1:${PORT}`)
})
